// 封装购物车模块
import { defineStore } from 'pinia'
import { computed, ref } from 'vue'
import { useUserStore } from './userStore'
import { delCartAPI, findCartListAPI, insertCartAPI, mergeCartAPI, updateCartAPI, updateSelectCartAPI } from '@/apis/cart'

export const useCartStore = defineStore(
  'cart',
  () => {
    // 判断是否登录
    const userStore = useUserStore()
    const isLogin = computed(() => {
        return userStore.userInfo.token
    })
    // 定义state - cartList 购物车列表
    const cartList = ref([])

    // 定义actions - updateCart 更新购物车列表
    const updateCartList = async () => {
      const res = await findCartListAPI()
      cartList.value = res.result
    }
    // 定义actions - getCartList 获取购物车列表
    // 未使用
    const getCartList = async () => {
      if(isLogin.value) {
        // 登录状态下获取购物车列表
        updateCartList()
      } else {
        // 未登录状态下获取购物车列表
        cartList.value = JSON.parse(localStorage.getItem('cart')).cartList || []
      }
    }
    // 定义actions - addCart 向购物车添加商品
    const addCart = async (goods) => {
      const { skuId, count } = goods
      if(isLogin.value) {
        // 登录状态下添加购物车操作
        await insertCartAPI({ skuId, count })
        // 获取最新的购物车列表
        updateCartList()
      } else {
        // 未登录状态下添加购物车操作
        // 添加购物车操作
        // 判断购物车中是否已经存在该商品，如果存在则数量加1，如果不存在则添加到购物车列表中
        // 查找购物车列表中是否存在该商品，如果不存在则返回-1
        // 思路：通过匹配传递过来的商品对象中的skuId和购物车列表中的商品对象的skuId是否相等来判断是否已经添加过该商品
        const item = cartList.value.find((item) => goods.skuId === item.skuId)
        if (item) {
          // 如果已经添加过该商品，则数量加1
          // item.count++
          // 购物车中商品数量累加，传递过来的商品数量和购物车中该商品的当前数量相加，如果传递过来的商品数量为空则默认为1
          item.count += goods.count || 1
        } else {
          // 如果没有添加过该商品，则添加到购物车列表中，数量为1
          cartList.value.push(goods)
        }
        // 思路：遍历购物车列表，如果找到该商品，则返回该商品在购物车列表中的索引，如果找不到则返回-1没有添加过
        // const index = cartList.value.findIndex((i) => i.skuId === goods.skuId)
        // if (index === -1) {
        //   cartList.value.push({ ...item, count: 1 })
        // } else {
        //   cartList.value[index].count++
        // }
        }
    }

    // 定义actions - delCart 从购物车删除商品
    const delCart = async (skuId) => {
      if(isLogin.value) {
        // 登录状态下删除购物车操作
        await delCartAPI([skuId])
        // 获取最新的购物车列表
        updateCartList()
      } else {
        // 删除购物车操作
        // 思路1：找到要删除商品的索引，然后使用splice方法删除该商品
        // const index = cartList.value.findIndex((item) => item.skuId === skuId)
        // if (index !== -1) {
        //   cartList.value.splice(index, 1)
        // }
        // 思路2：直接使用filter方法过滤掉要删除的商品，然后重新赋值给购物车列表
        cartList.value = cartList.value.filter((item) => item.skuId !== skuId)
      }
    }

    // 定义actions - clearCart 清空购物车
    const clearCart = async () => {
      cartList.value = []
    }

    // 定义actions - mergeCartList 合并购物车列表
    // 未登录情况下，用户在购物车页面添加商品，然后登录，此时需要将未登录状态下添加的商品合并到登录状态下
    const mergeCart = async () => {
      // 合并购物车列表
      await mergeCartAPI(cartList.value.map( item => {
        return {
          skuId: item.skuId,
          selected: item.selected,
          count: item.count,
        }
      }))
      // 获取最新的购物车列表
      updateCartList()
    }

    // 定义actions - singleCheck 单个商品的选中状态
    const singleCheck = async (skuId, selected,count) => {

      // 未登录状态下添加购物车操作
      // 查找购物车列表中是否存在该商品，如果存在则修改该商品的选中状态
      const item = cartList.value.find((item) => item.skuId === skuId)
      if (item) {
        item.selected = selected
      }
      // 如果登录
      if(isLogin.value) {
        // 登录状态下修改购物车商品的状态和数量
        await updateCartAPI({ skuId, selected, count })
        // 获取最新的购物车列表
        // updateCartList()
      }
    }
    // 定义actions - allCheck 全选状态
    const allCheck = (selected) => {
      // 遍历购物车列表，修改每个商品的选中状态
      cartList.value.forEach((item) => item.selected = selected)
      // 如果登录
      if(isLogin.value) {
        // 登录状态下修改购物车商品的 选中状态
        // 获取所有的商品的id
        const ids = cartList.value.map(item => item.skuId)
        // 修改购物车商品的 选中状态
        updateSelectCartAPI({ selected, ids })
      }
    }

    // 计算属性 - totalCount 购物车商品数量
    const totalCount = computed(() => {
      // return cartList.value.reduce((p, c) => p + c.count, 0)
      return cartList.value.length
    })
    // 计算属性 - totalPrice 购物车商品总价
    const totalPrice = computed(() => {
      return cartList.value.reduce((p, c) => p + c.count * c.price, 0)
    })
    // 计算属性 - isChecked 全选状态
    const isChecked = computed(() => {
      return cartList.value.every((item) => item.selected) && cartList.value.length > 0
    })
    // 计算属性 - isIndeterminate 部分选中状态
    const isIndeterminate = computed(() => {
      // 如果购物车列表为空，则返回false
      // if (cartList.value.length === 0) {
      //   return false
      // }
      // 如果购物车列表不为空，则判断购物车列表中是否所有商品都被选中，如果都被选中和一个都没选则返回false，否则返回true
      // 统计选中商品的数量
      const selectedCount = cartList.value.filter(item => item.selected).length;
      // 如果所有商品都被选中或者一个都没选，则返回false，否则返回true
      return selectedCount !== 0 && selectedCount !== cartList.value.length && cartList.value.length > 0;
    })
    // 计算属性 - selectedNumber 选中商品件数
    const selectedNumber = computed(() => {
      return cartList.value.filter(item => item.selected).length;
    })
    // 计算属性 - selectedCount 选中商品数量
    const selectedCount = computed(() => {
      // return cartList.value.filter(item => item.selected).length;
      return cartList.value.filter(item => item.selected).reduce((p, c) => p + c.count, 0)
    })
    // 计算属性 - selectedPrice 选中商品总价
    const selectedPrice = computed(() => {
      return cartList.value.filter(item => item.selected).reduce((p, c) => p + c.count * c.price, 0);
    })

    // 返回state和actions
    return {
      cartList,
      updateCartList,
      addCart,
      delCart,
      clearCart,
      mergeCart,
      singleCheck,
      allCheck,
      totalCount,
      totalPrice,
      isChecked,
      isIndeterminate,
      selectedNumber,
      selectedCount,
      selectedPrice
    }
  }, {
    persist: true // 持久化存储
  }
)
